home *** CD-ROM | disk | FTP | other *** search
/ 9-Digit Zip Code Directory / 9-Digit Zip Code Directory (American Business Information) (ABIZIP-12).ISO / z4src.zip / Z4DATA.C < prev    next >
C/C++ Source or Header  |  1995-08-24  |  17KB  |  625 lines
  1. //----------------------------------------------------------------------------
  2. //                            MODULE DESCRIPTION
  3. //
  4. //  Module:    zbdata.c
  5. //   Title:    ZIP+4 File Build
  6. //  Notice:    John M. Weeder
  7. //                 Copyright (c) 1993. All rights reserved.
  8. //             This module contains proprietary information and should be 
  9. //                treated as confidential.
  10. //
  11. //----------------------------------------------------------------------------
  12. //                           MAINTENANCE HISTORY
  13. //
  14. // $Workfile$
  15. // $Revision$
  16. //   $Author$
  17. //     $Date$
  18. //      $Log$    
  19. //
  20. //----------------------------------------------------------------------------
  21. //                             MODULE NARRATIVE
  22. //
  23. //
  24. //    This module contains the abbreviated state name table.
  25. //
  26. //    The code in this module should be written entirely in C. 
  27. //    Do not use any C++ constructs.
  28. //
  29. //    This module is portable to:
  30. //        DOS 3.X+
  31. //        MS Windows 3.X+
  32. //        OS/2 2.X+
  33. //        OS/2 2.0 PM
  34. //        SCO UNIX.
  35. //
  36. //    The following compilers are supported:
  37. //        MSC 6.0A
  38. //        MSC/C++ 7.0
  39. //        Borland C++ 3.1 for DOS
  40. //        Borland C++ 1.0 for OS/2 2.X
  41. //        SCO UNIX cc
  42. //
  43. //----------------------------------------------------------------------------
  44. #include <z4.h>
  45.  
  46.  
  47. //----------------------------------------------------------------------------
  48. //    Abbreviated state names
  49. //----------------------------------------------------------------------------
  50. static PCSZ _z4_apszZip4State[] = // This table should be alphabetical
  51.     {                             //  and match the enumeration in z4.h
  52.     "\0",                         // Invalid state code!!!
  53. #if USE_STATES_ONLY==0
  54.    "AA\0ARMED FORCES AMERICAS",
  55.    "AE\0ARMED FORCES EUROPE",
  56. #endif
  57.    "AK\0ALASKA",
  58.    "AL\0ALABAMA",
  59. #if USE_STATES_ONLY==0
  60.    "AP\0ARMED FORCES PACIFIC",
  61. #endif
  62.    "AR\0ARKANSAS",
  63. #if USE_STATES_ONLY==0
  64.    "AS\0AMERICAN SOMOA",
  65. #endif
  66.    "AZ\0ARIZONA",
  67.    "CA\0CALIFORNIA",
  68.    "CO\0COLORADO",
  69.    "CT\0CONNECTICUT",
  70.    "DC\0DISTRICT OF COLUMBIA",
  71.    "DE\0DELAWARE",
  72.    "FL\0FLORIDA",
  73. #if USE_STATES_ONLY==0
  74.    "FM\0FEDERATED STATES OF MICRONESIA",
  75. #endif
  76.    "GA\0GEORGIA",
  77. #if USE_STATES_ONLY==0
  78.    "GU\0GUAM",
  79. #endif
  80.    "HI\0HAWAII",
  81.    "IA\0IOWA",
  82.    "ID\0IDAHO",
  83.    "IL\0ILLINOIS",
  84.    "IN\0INDIANA",
  85.    "KS\0KANSAS",
  86.    "KY\0KENTUCKY",
  87.    "LA\0LOUISIANA",
  88.    "MA\0MASSACHUSSETTS",
  89.    "MD\0MARYLAND",
  90.    "ME\0MAINE",
  91. #if USE_STATES_ONLY==0
  92.    "MH\0MARSHALL ISLANDS",
  93. #endif
  94.    "MI\0MICHIGAN",
  95.    "MN\0MINNESOTA",
  96.    "MO\0MISSOURI",
  97. #if USE_STATES_ONLY==0
  98.    "MP\0NORTHERN MARIANA ISLANDS",
  99. #endif
  100.    "MS\0MISSISSIPPI",
  101.    "MT\0MONTANA",
  102.    "NC\0NORTH CAROLINA",
  103.    "ND\0NORTH DAKOTA",
  104.    "NE\0NEBRASKA",
  105.    "NH\0NEW HAMPSHIRE",
  106.    "NJ\0NEW JERSEY",
  107.    "NM\0NEW MEXICO",
  108.    "NV\0NEVADA",
  109.    "NY\0NEW YORK",
  110.    "OH\0OHIO",
  111.    "OK\0OKLAHOMA",
  112.    "OR\0OREGON",
  113.    "PA\0PENNSYLVANIA",
  114. #if USE_STATES_ONLY==0
  115.    "PR\0PUERTO RICO",
  116.    "PW\0PALAU",
  117. #endif
  118.    "RI\0RHODE ISLAND",
  119.    "SC\0SOUTH CAROLINA",
  120.    "SD\0SOUTH DAKOTA",
  121.    "TN\0TENNESSEE",
  122.    "TX\0TEXAS",
  123.    "UT\0UTAH",
  124.    "VA\0VIRGINIA",
  125. #if USE_STATES_ONLY==0
  126.    "VI\0VIRGIN ISLANDS",
  127. #endif
  128.    "VT\0VERMONT",
  129.    "WA\0WASHINGTON",
  130.    "WI\0WISCONSIN",
  131.    "WV\0WEST VIRGINIA",
  132.    "WY\0WYOMING",
  133.    NULL
  134.    };
  135.  
  136.  
  137. //----------------------------------------------------------------------------
  138. //   Description:
  139. //    Parameters:
  140. //       Returns:    
  141. //----------------------------------------------------------------------------
  142. PCSZ FN_E Z4State(Z4_STATE cWhich, SIZET cMode)
  143. {
  144.     PCSZ pcsz;
  145.  
  146.     Assert(cWhich < sizeof(_z4_apszZip4State) / sizeof(PCSZ));
  147.     pcsz = _z4_apszZip4State[cWhich];
  148.     switch (cMode)
  149.         {
  150.         case Z4_DATA_ABBREV:
  151.         case Z4_DATA_CODE:
  152.         case Z4_DATA_EXPERT:
  153.             return pcsz;
  154.  
  155.         case Z4_DATA_FULL:
  156.         case Z4_DATA_NOVICE:
  157.         default:
  158.             return strchr(pcsz, '\0') + 1;
  159.         }
  160. }
  161.  
  162.  
  163. //----------------------------------------------------------------------------
  164. //   Description:
  165. //    Parameters:
  166. //       Returns:    
  167. //----------------------------------------------------------------------------
  168. Z4_STATE FN_E Z4FindState(PCSZ pcsz)
  169. {
  170.     SIZET i;
  171.  
  172.     for (i = Z4_ST_FIRST; _z4_apszZip4State[i]; ++i)
  173.       if (strcmp(_z4_apszZip4State[i], pcsz) == 0)
  174.         return (Z4_STATE)i;
  175.     return Z4_ST_INVALID;
  176. }
  177.  
  178.  
  179. //----------------------------------------------------------------------------
  180. //    City/state record type
  181. //    The first string is the string found in the USPS record. 
  182. //    The second string is the external (user friendly) description.
  183. //  The third string is the technical description.
  184. //----------------------------------------------------------------------------
  185. static PCSZ _z4_apszCSRecordType[] =    // This table must match the 
  186.     {                                   //  enumeration in z4.h
  187.     "P\0PO BOX'es only.\0PO Box",         //counted as 0
  188.     "\0Standard ZIP code.\0Non-Unique",  //           1
  189.     "U\0Non-standard ZIP code.\0Unique",  //           2
  190.     "M\0Military ZIP code.\0Military",    //           3
  191.     NULL                  // whichever number it pulls
  192.     };
  193.  
  194.  
  195. //----------------------------------------------------------------------------
  196. //   Description:    
  197. //    Parameters:
  198. //       Returns:
  199. //----------------------------------------------------------------------------
  200. PCSZ FN_E Z4CSRecordType(Z4_CS_TYPE cWhich, SIZET cMode)
  201. {
  202.     PCSZ pcsz;
  203.  
  204.     Assert(cWhich < sizeof(_z4_apszCSRecordType) / sizeof(PCSZ));
  205.     pcsz = _z4_apszCSRecordType[cWhich];
  206.     switch (cMode)
  207.         {
  208.         case Z4_DATA_CODE:
  209.             return pcsz;
  210.  
  211.         case Z4_DATA_FULL:
  212.         case Z4_DATA_NOVICE:
  213.             return strchr(pcsz, '\0') + 1;
  214.  
  215.         case Z4_DATA_ABBREV:
  216.         case Z4_DATA_EXPERT:
  217.         default:
  218.             return strchr(strchr(pcsz, '\0') + 1, '\0') + 1;
  219.         }
  220. }
  221.  
  222.  
  223. //----------------------------------------------------------------------------
  224. //   Description:    
  225. //    Parameters:
  226. //       Returns:    
  227. //----------------------------------------------------------------------------
  228. Z4_CS_TYPE FN_E Z4FindCSRecordType(PCSZ pcsz)
  229. {
  230.     SIZET i;
  231.  
  232.     for (i = 0; _z4_apszCSRecordType[i]; ++i)
  233.     if (strcmp(_z4_apszCSRecordType[i], pcsz) == 0)
  234.         return (Z4_CS_TYPE)i;
  235.        return Z4_CS_TYPE_INVALID;
  236. }
  237.  
  238.  
  239. //----------------------------------------------------------------------------
  240. //    City/state facility code
  241. //    The first string is the string found in the USPS record. 
  242. //    The second string is the external (user friendly) description.
  243. //    The third string is the technical description.
  244. //----------------------------------------------------------------------------
  245. static PCSZ _z4_apszFacility[] =            // This table must match the 
  246.     {                                       //  enumeration in z4.h
  247.     "A\0Airport Mail Facility\0Airport Mail Facility",  //added
  248.     "B\0Branch\0Branch",
  249.     "C\0Community Post Office\0Community Post Office",
  250.     "D\0Area Distribution Center\0Area Distribution Center",  //added
  251.     "E\0Sectional Center Facility\0Sectional Center Facility", //added
  252.     "F\0Delivery Distribution Center\0Delivery Distribution Center",  //added
  253.     "G\0General Mail Facility\0General Mail Facility",         //added
  254.     "K\0Bulk Mail Center\0Bulk Mail Center",                  //added
  255.     "M\0Money Order Unit\0Money Order Unit",                  //added
  256.     "N\0Non-Postal Name\0Non-Postal Name",
  257.     "O\0Other\0Other",
  258.     "P\0Post Office\0Post Office",
  259.     "S\0Station\0Station",                                      //added
  260.     "U\0Urbanization\0Urbanization",
  261.     NULL
  262.     };
  263.  
  264.  
  265. //----------------------------------------------------------------------------
  266. //   Description:    
  267. //    Parameters:
  268. //       Returns:    
  269. //----------------------------------------------------------------------------
  270. PCSZ FN_E Z4Facility(Z4_FACILITY cWhich, SIZET cMode)
  271. {
  272.     PCSZ pcsz;
  273.  
  274.     Assert(cWhich < sizeof(_z4_apszFacility) / sizeof(PCSZ));
  275.     pcsz = _z4_apszFacility[cWhich];
  276.     switch (cMode)
  277.         {
  278.         case Z4_DATA_CODE:
  279.             return pcsz;
  280.  
  281.         case Z4_DATA_FULL:
  282.         case Z4_DATA_NOVICE:
  283.             return strchr(pcsz, '\0') + 1;
  284.  
  285.         case Z4_DATA_ABBREV:
  286.         case Z4_DATA_EXPERT:
  287.         default:
  288.             return strchr(strchr(pcsz, '\0') + 1, '\0') + 1;
  289.         }
  290. }
  291.  
  292.  
  293. //----------------------------------------------------------------------------
  294. //   Description:    
  295. //    Parameters:
  296. //       Returns:    
  297. //----------------------------------------------------------------------------
  298. Z4_FACILITY FN_E Z4FindFacility(PCSZ pcsz)
  299. {
  300.     SIZET i;
  301.  
  302.     for (i = 0; _z4_apszFacility[i]; ++i)
  303.     if (strcmp(_z4_apszFacility[i], pcsz) == 0)
  304.         return (Z4_FACILITY)i;
  305.  
  306.     return Z4_FACILITY_INVALID;
  307. }
  308.  
  309.  
  310. //----------------------------------------------------------------------------
  311. //    ZIP+4 record type
  312. //    The first string is the string found in the USPS record. 
  313. //    The second string is the external (user friendly) description.
  314. //    The third string is the technical description.
  315. //----------------------------------------------------------------------------
  316. static PCSZ _z4_apszZ4RecordType[] =    // This table must match the 
  317.     {                //  enumeration in z4.h
  318.     "S\0Street or other address.\0Street",                     // chgd fm 10 to S
  319.     "P\0Post office box address.\0PO BOX",                     // chgd fm 14 to P
  320.     "R\0Rural route or highway contract address.\0Rural Route",// chgd fm 18 to R
  321.     "H\0Building or apartment address.\0Highrise",             // chgd fm 20 to H
  322.     "F\0Named business address.\0Firm",                        // chgd fm 21 to F
  323.     "M\0Postmaster address.\0Postmaster",                      // chgd fm 22 to M
  324.     "G\0General delivery address.\0General delivery",          // chgd fm 26 to G
  325.     NULL
  326.     };
  327.  
  328.  
  329. //----------------------------------------------------------------------------
  330. //   Description:    
  331. //    Parameters:
  332. //       Returns:    
  333. //----------------------------------------------------------------------------
  334. PCSZ FN_E Z4Z4RecordType(Z4_TYPE cWhich, SIZET cMode)
  335. {
  336.     PCSZ pcsz;
  337.  
  338.     Assert(cWhich < sizeof(_z4_apszZ4RecordType) / sizeof(PCSZ));
  339.     pcsz = _z4_apszZ4RecordType[cWhich];
  340.     switch (cMode)
  341.         {
  342.         case Z4_DATA_CODE:
  343.             return pcsz;
  344.  
  345.         case Z4_DATA_FULL:
  346.         case Z4_DATA_NOVICE:
  347.             return strchr(pcsz, '\0') + 1;
  348.  
  349.         case Z4_DATA_ABBREV:
  350.         case Z4_DATA_EXPERT:
  351.         default:
  352.             return strchr(strchr(pcsz, '\0') + 1, '\0') + 1;
  353.         }
  354. }
  355.  
  356.  
  357. //----------------------------------------------------------------------------
  358. //   Description:    
  359. //    Parameters:
  360. //       Returns:    
  361. //----------------------------------------------------------------------------
  362. Z4_TYPE FN_E Z4FindZ4RecordType(PCSZ pcsz)
  363. {
  364.     SIZET i;
  365.  
  366.     for (i = 0; _z4_apszZ4RecordType[i]; ++i)
  367.     if (strcmp(_z4_apszZ4RecordType[i], pcsz) == 0)
  368.         return (Z4_TYPE)i;
  369.  
  370.     return Z4_TYPE_INVALID;
  371. }
  372.  
  373.  
  374. //----------------------------------------------------------------------------
  375. //    Directional codes
  376. //----------------------------------------------------------------------------
  377. static PCSZ _z4_apszDirectional[] =        // This table must match the 
  378.     {                                                //  enumeration in z4.h
  379.     "\0",
  380.     "N\0NORTH",       
  381.     "E\0EAST",             
  382.     "S\0SOUTH",         
  383.     "W\0WEST",             
  384.     "NE\0NORTHEAST",     
  385.     "SE\0SOUTHEAST",     
  386.     "SW\0SOUTHWEST",     
  387.     "NW\0NORTHWEST",     
  388.     NULL
  389.     };
  390.  
  391.  
  392. //----------------------------------------------------------------------------
  393. //   Description:    
  394. //    Parameters:
  395. //       Returns:    
  396. //----------------------------------------------------------------------------
  397. PCSZ FN_E Z4Directional(Z4_DIR cWhich, SIZET cMode)
  398. {
  399.     PCSZ pcsz;
  400.  
  401.     Assert(cWhich < sizeof(_z4_apszDirectional) / sizeof(PCSZ));
  402.     pcsz = _z4_apszDirectional[cWhich];
  403.     switch (cMode)
  404.         {
  405.         case Z4_DATA_ABBREV:
  406.         case Z4_DATA_CODE:
  407.         case Z4_DATA_EXPERT:
  408.             return pcsz;
  409.  
  410.         case Z4_DATA_FULL:
  411.         case Z4_DATA_NOVICE:
  412.         default:
  413.             return strchr(pcsz, '\0') + 1;
  414.         }
  415. }
  416.  
  417.  
  418. //----------------------------------------------------------------------------
  419. //   Description:    
  420. //    Parameters:
  421. //       Returns:    
  422. //----------------------------------------------------------------------------
  423. Z4_DIR FN_E Z4FindDirectional(PCSZ pcsz)
  424. {
  425.     SIZET i;
  426.  
  427.     for (i = 0; _z4_apszDirectional[i]; ++i)
  428.         if (strcmp(_z4_apszDirectional[i], pcsz) == 0)
  429.             return (Z4_DIR)i;
  430.  
  431.     return Z4_DIR_INVALID;
  432. }
  433.  
  434.  
  435. //----------------------------------------------------------------------------
  436. //    Unit designators
  437. //----------------------------------------------------------------------------
  438. static PCSZ _z4_apszUnit[] =                // This table must match the 
  439.     {                                                //  enumeration in z4.h
  440.     "\0#",
  441.     "#\0#",
  442.     "APT\0APARTMENT",
  443.     "BOX\0BOX",
  444.     "BLDG\0BUILDING",
  445.     "DEPT\0DEPARTMENT",
  446.     "FL\0FLOOR",
  447.     "HNGR\0HANGER",
  448.     "LOT\0LOT",
  449.     "PIER\0PEIR",
  450.     "RM\0ROOM",
  451.     "SLIP\0SLIP",
  452.     "STE\0SUITE",
  453.     "STOP\0STOP",
  454.     "TRLR\0TRAILER",
  455.     "UNIT\0UNIT",
  456.     "BSMT\0BASEMENT ",
  457.     "FRNT\0FRONT",
  458.     "LBBY\0LOBBY",
  459.     "LOWR\0LOWER",
  460.     "OFC\0OFFICE",
  461.     "PH\0PENTHOUSE",
  462.     "REAR\0REAR",
  463.     "SIDE\0SIDE",
  464.     "UPPR\0UPPER",
  465.     NULL
  466.     };
  467.  
  468.  
  469. //----------------------------------------------------------------------------
  470. //   Description:    
  471. //    Parameters:
  472. //       Returns:
  473. //----------------------------------------------------------------------------
  474. PCSZ FN_E Z4Unit(Z4_UNIT cWhich, SIZET cMode)
  475. {
  476.     PCSZ pcsz;
  477.  
  478.     Assert(cWhich < sizeof(_z4_apszUnit) / sizeof(PCSZ));
  479.     pcsz = _z4_apszUnit[cWhich];
  480.     switch (cMode)
  481.         {
  482.         case Z4_DATA_ABBREV:
  483.         case Z4_DATA_CODE:
  484.         case Z4_DATA_EXPERT:
  485.             return pcsz;
  486.  
  487.         case Z4_DATA_FULL:
  488.         case Z4_DATA_NOVICE:
  489.         default:
  490.             return strchr(pcsz, '\0') + 1;
  491.         }
  492. }
  493.  
  494.  
  495. //----------------------------------------------------------------------------
  496. //   Description:    
  497. //    Parameters:
  498. //       Returns:
  499. //----------------------------------------------------------------------------
  500. Z4_UNIT FN_E Z4FindUnit(PCSZ pcsz)
  501. {
  502.     SIZET i;
  503.  
  504.     for (i = 0; _z4_apszUnit[i]; ++i)
  505.         if (strcmp(pcsz, _z4_apszUnit[i]) == 0)
  506.             return (Z4_UNIT)i;
  507.  
  508.     return Z4_UNIT_BLANK;
  509. }
  510.  
  511.  
  512. //----------------------------------------------------------------------------
  513. //    Odd/even/both
  514. //----------------------------------------------------------------------------
  515. static PCSZ _z4_apszCode[] =                // This table must match the 
  516.     {                                      //  enumeration in z4.h
  517.     "\0",
  518.     "B\0Both",
  519.     "O\0Odd",
  520.     "E\0Even",
  521.     NULL
  522.     };
  523.  
  524.  
  525. //----------------------------------------------------------------------------
  526. //   Description:    
  527. //    Parameters:
  528. //       Returns:    
  529. //----------------------------------------------------------------------------
  530. PCSZ FN_E Z4Code(Z4_CODE cWhich, SIZET cMode)
  531. {
  532.     PCSZ pcsz;
  533.  
  534.     Assert(cWhich < sizeof(_z4_apszCode) / sizeof(PCSZ));
  535.     pcsz = _z4_apszCode[cWhich];
  536.     switch (cMode)
  537.         {
  538.         case Z4_DATA_ABBREV:
  539.         case Z4_DATA_CODE:
  540.         case Z4_DATA_EXPERT:
  541.             return pcsz;
  542.  
  543.         case Z4_DATA_NOVICE:
  544.         case Z4_DATA_FULL:
  545.         default:
  546.             return strchr(pcsz, '\0') + 1;
  547.         }
  548. }
  549.  
  550.  
  551. //----------------------------------------------------------------------------
  552. //   Description:    
  553. //    Parameters:
  554. //       Returns:    
  555. //----------------------------------------------------------------------------
  556. Z4_CODE FN_E Z4FindCode(PCSZ pcsz)
  557. {
  558.     SIZET i;
  559.  
  560.     for (i = 0; _z4_apszCode[i]; ++i)
  561.  
  562.     if (strcmp(_z4_apszCode[i], pcsz) == 0)
  563.     return (Z4_CODE)i;
  564.  
  565.     return Z4_CODE_INVALID;
  566. }
  567.  
  568.  
  569. //----------------------------------------------------------------------------
  570. //    Odd/even/both
  571. //----------------------------------------------------------------------------
  572. static PCSZ _z4_apszAlt[] =                // This table must match the 
  573.     {                                                //  enumeration in z4.h
  574.     "B\0Base",
  575.     "A\0Alternate",
  576.     NULL
  577.     };
  578.  
  579.  
  580. //----------------------------------------------------------------------------
  581. //   Description:    
  582. //    Parameters:
  583. //       Returns:    
  584. //----------------------------------------------------------------------------
  585. PCSZ FN_E Z4Alt(Z4_ALT cWhich, SIZET cMode)
  586. {
  587.     PCSZ pcsz;
  588.  
  589.     Assert(cWhich < sizeof(_z4_apszAlt) / sizeof(PCSZ));
  590.     pcsz = _z4_apszAlt[cWhich];
  591.     switch (cMode)
  592.         {
  593.         case Z4_DATA_CODE:
  594.         case Z4_DATA_ABBREV:
  595.             return pcsz;
  596.  
  597.         case Z4_DATA_FULL:
  598.         case Z4_DATA_EXPERT:
  599.         case Z4_DATA_NOVICE:
  600.         default:
  601.             return strchr(pcsz, '\0') + 1;
  602.         }
  603. }
  604.  
  605.  
  606. //----------------------------------------------------------------------------
  607. //   Description:    
  608. //    Parameters:
  609. //       Returns:    
  610. //----------------------------------------------------------------------------
  611. Z4_ALT FN_E Z4FindAlt(PCSZ pcsz)
  612. {
  613.     SIZET i;
  614.  
  615.     for (i = 0; _z4_apszAlt[i]; ++i)
  616.         if (strcmp(_z4_apszAlt[i], pcsz) == 0)
  617.             return (Z4_ALT)i;
  618.  
  619.     return Z4_ALT_INVALID;
  620. }
  621. //----------------------------------------------------------------------------
  622. //------------------------------- End of File --------------------------------
  623. //----------------------------------------------------------------------------
  624.  
  625.